Rs error correction decoding method

ABSTRACT

A decoding method includes that when encoding at a sending terminal, for a m-order primitive polynomial P(x), a primitive field element in galois field GF(2 m ) is represented by α; a lookup table f(α j ) for different power exponents of α is established, where the value of j is selected from all the integers ranging from 0 to 2m−1, with a total number of 2m; a generator polynomial G(x) is expanded to obtain a polynomial with respect to x, with coefficients being an addition or subtraction of the power exponents of α; a remainder polynomial R(x), obtained by dividing code word polynomial Q(x) by the generator polynomial G(x), is a polynomial with respect to x, with coefficients being an addition or subtraction of the power exponents of α; and the coefficients of the generator polynomial G(x) and the remainder polynomial R(x) are both calculated using data found in the lookup table f(α j ).

CROSS REFERENCE TO RELATED APPLICATIONS

The present application is a Continuation Application of PCT Application No. PCT/CN2016/091012 filed on Jul. 22, 2016, which claims the benefit of Chinese Patent Application No. 201510461188.4 filed on Jul. 31, 2015. All the above are hereby incorporated by reference.

FIELD OF THE INVENTION

The present invention relates to the technical field of error correction codes, and in particular to a Reed-Solomon (RS) error correction decoding method.

BACKGROUND OF THE INVENTION

In a communication system, it is necessary to artificially add redundant codes to the data stream according to certain rules before information is sent so that a receiving terminal can detect and correct error codes. RS error correction code is currently one of the most effective and widely used error control encoding measures. RS codes can be used to correct random errors, and are also suitable for correcting burst errors, and have been widely used in areas such as satellite communications, digital television transmission or the like.

(c, k, 2t) are typically used to represent RS codes; where c is the total length of information data and redundant code, k is the length of the information data, 2t is the length of the redundant code, and t is the maximum number of errors that can be corrected, where c=K+2t.

The number of elements in the Galois field (GF) in the conventional RS error correction algorithm is related to the number of primitive polynomials. For example, if the order of a primitive polynomials is 8, then the number of elements in the GF is 2⁸, i.e., 256, the elements in the GF are used for a lookup table in the RS error correction calculation process, and the number of elements in the lookup table reaches 256; and if the order of a primitive polynomial is 16, then the number of elements in the GF is 2¹⁶, i.e., 65536, which occupies more memory space, and therefore the speed of data processing is slow and the application thereof is limited. In addition, if the number of actual error code words exceeds the error correction capacity, a situation that more errors occur as the error correction proceeds may arise.

In addition, in conventional RS error correction algorithms, the error codes are not checked after being found and corrected, so the stability and correctness of the system is not high.

Chinese invention patent publication No. CN1303763C discloses a method for reducing the complexity of encoding and decoding RS codes. The invention has the following main features: when encoding at a sending terminal, the code element of the RS code is represented by the power of the primitive field element a, and code words of the RS codes are all in the finite field GF (2^(m)), and all non-zero elements in the finite field GF (2^(m)) are integer powers of the primitive field element α. In coding and decoding, for any two elements X and Y in the finite field GF (2^(m)), multiplication of X and Y equals to addition of the corresponding two exponents, and the addition and subtraction of X and Y are performed using a lookup table. In this way, the coding and decoding method is improved based on existing RS coding and decoding algorithms, the complicated multiplication operation can be avoided and the coding and decoding speed is improved. However, for the finite field GF (2^(m)), three lookup tables have to be established, i and x′ in each group are stored in two long lookup tables, power [ ] and index [ ], and there is a further lookup table f(s), where s is selected from all the integers ranging from 0 to 2^(m)−1, with a total number of 2^(m). While the calculation speed is fast, the data memory occupied is relatively large, and after the RS error codes are corrected using the redundant codes, no valid data are used for checking, resulting in low security and stability.

SUMMARY OF THE INVENTION

The technical problem to be addressed by the present invention is to provide a RS error correction decoding method which occupies less memory.

In order to address the above technical problem, the invention provides the following technical solutions:

A RS error correction decoding method, in which,

-   -   when encoding at a sending terminal, code words of information         data are represented by K_(l), code words of redundant codes are         represented by T, the order of primitive polynomial P(x) is m, a         generator polynomial in GF(2^(m)) is G(x), and an error         correction code is represented by (c, k, t), wherein c is the         total length of the information data and the redundant code, k         is the length of the information data, and t is the length of         the redundant code, then the code word polynomial Q(x) can be         represented as

${{Q(x)} = {{\sum\limits_{l = t}^{t + k - 1}{K_{l} \cdot x^{l}}} + {\sum\limits_{n = 0}^{t - 1}{T_{n} \cdot x^{n}}}}};$

-   -   root of the m-order primitive polynomial P(x) is primitive field         element in GF (2^(m)), and the primitive field element is         represented by α, thus the generator polynomial G(x) can be         represented as

${{G(x)} = {\prod\limits_{t = 1}^{t}\left( {x - \alpha^{i}} \right)}};$

-   -   a lookup table f(α^(j)) is established for different power         exponents of α, wherein the value of j is selected from all the         integers ranging from 0 to 2m−1, with a total number of 2m;     -   the generator polynomial G(x) is expanded to obtain a polynomial         with respect to x, wherein the coefficients of the generator         polynomial G(x) are the addition or subtraction of the power         exponents of α;     -   numerical values of the different power exponents of α are found         out through the lookup table f(α^(j)) and the coefficients of         the generator polynomial G(x) are calculated;     -   it is assumed that the code words T of the redundant codes are         all 0, then a code word polynomial

${Q(x)} = {\sum\limits_{l = t}^{t + k - 1}{K_{l} \cdot x^{l}}}$

is obtained;

-   -   the code word polynomial Q(x) is divided by the generator         polynomial G(x) to obtain a remainder polynomial

${{R(x)} = {\sum\limits_{i = 0}^{2s}{T_{i} \cdot x_{i}}}};$

-   -   the coefficients Ti of R(x) are the addition or subtraction of         the power exponents of α; numerical values of the power         exponents of α are found out through the lookup table f(α^(j)),         and the coefficients of the remainder polynomial R(x) are         calculated, namely, the code words Tn of the redundant codes.

The invention has the following advantageous effects: a lookup table f(α^(j)) consisting of 2m exponents of the primitive field element α is established in the finite field GF (2^(m)) to calculate the coefficients of the generator polynomial G(x) and the coefficients of the remainder polynomial R(x) obtained by dividing the code word polynomial Q(x) by the generator polynomial G(x), and the number of data in the lookup table f(α^(j)) is greatly reduced, thus saving a great deal of system memory and improving the flexibility and convenience in applying the RS error correction algorithm.

BRIEF DESCRIPTION OF THE ACCOMPANYING DRAWINGS

FIG. 1 is a flowchart of performing RS encoding by a sending terminal according to a first embodiment of the present invention; and

FIG. 2 is a flowchart of RS encoding and error correction according to the first embodiment of the present invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

The disclosure, objects and effects of the present invention will be described in detail below with reference to the embodiments and accompanying drawings.

The critical concept of the present invention is to establish a lookup table f(α^(j)) for different power exponents of α for a m-order primitive polynomial P(x), where j is selected from all the integers ranging from 0 to 2m−1, with a total number of 2m, for the calculation of coefficients of a generator polynomial G(x) and coefficients of a remainder polynomial R(x) obtained by dividing a code word polynomial Q(x) by the generator polynomial G(x), thus greatly saving the system memory; and a redundant code is additionally taken during encoding, for checking the data obtained by error correction decoding so as to improve system correctness and stability.

The technical term involved in the present invention is explained in Table 1:

TABLE 1 Technical term Interpretation polynomial A number is represented by a sum of a group of bases (1, representation α, α², . . . , α^(n−1)), and the group of bases are referred to as standard bases

Referring to FIG. 1 and FIG. 2, a specific embodiment of the present invention is described as follows.

A RS error correction decoding method is provided, in which,

-   -   when encoding at a sending terminal, code words of information         data are represented by K_(l), code words of redundant codes are         represented by T_(n), the order of primitive polynomial P(x) is         m, a generator polynomial in GF(2^(m)) is G(x), and an error         correction code is represented by (c, k, t), wherein c is the         total length of the information data and the redundant code, k         is the length of the information data, and t is the length of         the redundant code, then the code word polynomial Q(x) can be         represented as

${{Q(x)} = {{\sum\limits_{l = t}^{t + k - 1}{K_{l} \cdot x^{l}}} + {\sum\limits_{n = 0}^{t - 1}{T_{n} \cdot x^{n}}}}};$

-   -   root of the m-order primitive polynomial P(x) is primitive field         element in GF (2^(m)), and the primitive field element is         represented by α, thus the generator polynomial G(x) can be         represented as

${{G(x)} = {\prod\limits_{i = 1}^{t}\left( {x - a^{i}} \right)}};$

-   -   a lookup table f(α^(j)) is established for different power         exponents of α, wherein the value of j is selected from all the         integers ranging from 0 to 2m−1, with a total number of 2m;     -   the generator polynomial G(x) is expanded to obtain a polynomial         with respect to x, wherein the coefficients of the generator         polynomial G(x) are the addition or subtraction of the power         exponents of α;     -   numerical values of the different power exponents of α are found         out through the lookup table f(α^(j)) and the coefficients of         the generator polynomial G(x) are calculated;     -   it is assumed that the code words T_(n) of the redundant codes         are all 0, then a code word polynomial

${Q(x)} = {\sum\limits_{l = t}^{t + k - 1}{K_{l} \cdot x^{l}}}$

is obtained;

-   -   the code word polynomial Q(x) is divided by the generator         polynomial G(x) to obtain a remainder polynomial

${{R(x)} = {\sum\limits_{i = 0}^{2s}{T_{i} \cdot x_{i}}}};$

-   -   the coefficients Ti of R(x) are the addition or subtraction of         the power exponents of α; numerical values of the power         exponents of α are found out through the lookup table f(α^(j)),         and the coefficients of the remainder polynomial R(x) are         calculated, namely, the code word Tn of the redundant codes.

Further, the error correction decoding process is described as follows:

-   -   it is assumed that s is the maximum number of error correction         bits of a receiving terminal, let t=2s+1;     -   the code word polynomial Q(x) is divided by the generator         polynomial G(x) to obtain the remainder polynomial R(x),

${{R(x)} = {\sum\limits_{i = 0}^{2s}{T_{i} \cdot x_{i}}}};$

-   -   the coefficients of the remainder polynomial R(x) are         calculated, thus obtaining the code words T_(n) of 2s+1         redundant codes, n=1, 2, . . . , 2s+1;     -   the sending terminal sends information data and 2s+1 redundant         codes to the receiving terminal;     -   the receiving terminal receives the information data and 2s+1         redundant codes;     -   the receiving terminal obtains the code word polynomial Q(x) by         coding according to the received information data and 2s+1         redundant codes, and the code word polynomial Q(x) is         represented as

${{Q(x)} = {{\sum\limits_{l = {{2s} + 1}}^{{2s} + k}{K_{l} \cdot x^{l}}} + {\sum\limits_{n = 0}^{2s}{T_{n} \cdot x^{n}}}}};$

-   -   the receiving terminal calculates 2s+1 correctors S_(i), where         S_(i)=Q(α^(i)), i=1, 2, . . . , 2s+1;     -   a location and a correction value of error information code are         calculated using correctors S_(i)to S_(2s) if not all of the         correctors S, are equal to 0;     -   the correction value is added to the code word at the location         of the error information code received by the receiving terminal         to obtain an error-corrected code word;     -   the value of the error-corrected code word is assigned to the         code word at the location of the error information code;     -   S_(2s+1)=Q(α^(2s+1)) is recalculated, and if S_(2s+1)=0, the         error correction is successful, and if S_(2s+1)≠0, received         information code error is output and the error correction         capacity is insufficient for this.

As can be seen from the above description, 2s+1 redundant codes are obtained when the 0^(th) power of x is taken in calculating the redundant codes, and after the error correction codes are calculated using the 1^(st) to the 2s^(th) redundant codes, the (2s+1)^(th) redundant code is used to check whether the error-corrected code word polynomial is correct. In this way, the correctness of the error correction operation is effectively ensured, and the stability of system operation is improved.

Further, in the process of obtaining the remainder polynomial R(x) by dividing the code word polynomial Q(x) by the generator polynomial G(x), multiplication of the coefficients of x will be performed, and the multiplication is converted into addition in operation as follows.

-   -   the coefficients of x are represented by a polynomial         representation;     -   the coefficients represented by the polynomial representation         are multiplied and expanded to obtain addition of different         power exponents of α;

the numerical values of the different power exponents of α are found out by looking up the lookup table f(α^(j)) so as to solve the addition.

Further, the specific process of calculating the location of the error information code using the correctors S₁ to S_(2s) is described as follows:

-   -   a calculation is performed based on the correctors to obtain an         equation taking the location of the error information code as a         root;     -   the root of the equation is represented by a polynomial         representation, with standard bases being different power         exponents of α and coefficients being values of X_(i), where         i=0, 1, . . . , m;     -   the coefficients of the equation are represented by a polynomial         representation, with standard bases being different power         exponents of α;     -   the root and coefficients represented by the polynomial         representations are brought into the polynomial of the equation;     -   let the coefficient of each term of the polynomial be zero, thus         obtaining a non-homogeneous linear equations set for x_(i);     -   the non-homogeneous linear equation set is solved to obtain the         value of x_(i);     -   the value of x_(i) is brought into the root represented by the         polynomial representation to calculate the root of the equation         and obtain the location of the error information code;     -   the location in the code word polynomial Q(x) corresponding to         the location of the error information code is looked for.

Further, looking for the location in the code word polynomial Q(x) corresponding to the location of the error information code is specifically as follows:

-   -   a numerical value that is the same as the value of the error         information code is looked for in the lookup table f(α^(j)), and         the coefficient at the location where the exponent value of x in         the polynomial Q(x) is equal to the exponent value of α         corresponding to the numerical value is the location in the code         word polynomial Q(x) corresponding to the error information         code;     -   if the numerical value that is the same as the value of the         error information code is not found in the lookup table         f(α^(j)), the following method is used to find out the location         of the error information code, specifically:     -   in step S1, take p=2*m−1=31, v=α^(2m−1);     -   in step S2, let p=p+1;     -   in step S3, if the highest data bit of v is 1, v is firstly         shifted leftward by 1 bit, and then v=v+v₀, where v₀ is the         numerical value obtained by bringing x=α into the primitive         polynomial P(x) except for the term of the highest power of x;     -   if the highest data bit of v is 0, v is shifted leftward by 1         bit;     -   in step S4, the v obtained in step S3 is compared with the error         information code to see if they are equal:     -   if the v is equal to the error information code, the coefficient         corresponding to the p^(th) power of x in the code word         polynomial Q (x) is the location of the error information code;         and     -   If the v is not equal to the error information code, then turn         to step S2 to continue the process.

Further, using the correctors S₁ to S_(2s) to calculate the correction value is specifically as follows:

-   -   a equation set consisting of the location of the error         information code and the correction value is obtained, where the         error information code is the root of the equation set, and the         correction value is an unknown number of the equation set;     -   the correction value of the equation set is represented by the         polynomial representation, with standard bases being different         power exponents of α, and coefficients being values of x_(i),         i=0, 1, . . . , m;     -   the location of the error information code of the equation set         is represented by the polynomial representation, with standard         bases being different power exponents of α;     -   the correction value and coefficients represented by the         polynomial representation are brought into the polynomial of the         equation set;     -   let the coefficient of each term of the polynomial be zero, thus         obtaining a non-homogeneous linear equation set for x_(i);     -   the non-homogeneous linear equation set is solved to obtain the         value of x_(i);     -   the value of x_(i) is brought into the correction value         represented by the polynomial representation so as to calculate         the root of the equation set and obtain the correction value.

It can be seen from the above description that in the process of error correction decoding of RS operation, the coefficients and unknown numbers of polynomials are all represented by the polynomial representation, thus the multiplication operation can be converted into addition operation, and solving of equation or equation set can be converted into solving of the non-homogeneous linear equation set so that the complicated operations are simplified, and the calculation process is simplified. The requirements on hardware are reduced, and the correctness of system operation is improved. If the numerical value that is being looked for is beyond the numerical value range of the lookup table f(α^(j)), the numerical value can be calculated by exponential operation. Since the data beyond the numerical value range of the lookup table f(α^(j)) is less in the process of RS error correction decoding, only 2m data are established in the lookup table f(α^(j)), and the memory consumption is therefore reduced.

Referring to FIG. 1 and FIG. 2, the first embodiment of the present invention is described as follows.

A RS error correction decoding method is provided, in which

-   -   when encoding at a sending terminal, five code words of         information data, 0x1234, 0x5678, 0x3245, 0xabcd, 0xef10, are         represented by K_(l), l=5, and the primitive polynomial is         P(x)=x¹⁶+x⁵+x³+x²+1, the order of the primitive polynomial is         16, and for a generator polynomial in the GF(2¹⁶), k is the         length of information data, then, k is 5, t is the length of the         redundant code, s is the maximum number of error correction bits         by the receiving end and is 2; when taking t=2s+1, then t=5, c         is the total length of the information data and the redundant         code and is 10, the error correction code is represented by (c,         k, t), then (c, k, t) is (10, 5, 5), T_(n) represents the code         words of the redundant codes, n=1, 2, . . . , 5, then the code         word polynomial Q(x) can be represented as

${{Q(x)} = {{\sum\limits_{l = t}^{t + k - 1}{K_{l} \cdot x^{l}}} + {\sum\limits_{n = 0}^{t - 1}{T_{n} \cdot x^{n}}}}};$

-   -   a root of the 16-order primitive polynomial P(x) is a primitive         field element in GF (2¹⁶), and the primitive field element is         represented by α, then the generator polynomial G(x) can be         represented as

${{G(x)} = {\prod\limits_{i = 1}^{5}\; \left( {x - \alpha^{i}} \right)}};$

-   -   a lookup table f(α^(j)) for different power exponents of α is         established, where the value of j is selected from all the         integers ranging from 0 to 31, with a total number of 2m,         specifically:         {1,2,4,8,0x10,0x20,0x40,0x80,0x100,0x200,0x400,0x800,0x1000,0x2000,         0x4000,0x8000,0x2d,0x5a,0xb4,0x168.0x2d0,0x5a0,0xb40,0x1680,0x2d00,         0x5a00,0xb400,0x682d,0xd05a,0xa099,0x411f,0x8233};     -   the generator polynomial G(x) is expanded to obtain a polynomial         with respect to x, where the coefficients of the generator         polynomial G(x) are addition or subtraction of the power         exponents of α, specifically:

${{G(x)} = {{\prod\limits_{i = 1}^{5}\; \left( {x - \alpha^{i}} \right)} = {{\left( {x - \alpha} \right)\left( {x - \alpha^{2}} \right)\left( {x - \alpha^{3}} \right)\left( {x - \alpha^{4}} \right)\left( {x - \alpha^{5}} \right)} = {x^{5} + {\left( {\alpha + \alpha^{2} + \alpha^{3} + \alpha^{4} + \alpha^{5}} \right)x^{4}} + {\left( {\alpha^{3} + \alpha^{4} + \alpha^{8} + \alpha^{9}} \right)x^{3}} + {\left( {\alpha^{7} + \alpha^{8} + \alpha^{11} + \alpha^{12}} \right)x^{2}} + {\left( {\alpha^{10} + \alpha^{11} + \alpha^{12} + \alpha^{13} + \alpha^{14}} \right)x} + \alpha^{15}}}}};$

-   -   numerical values of the different power exponents of α are found         out through the lookup table f(α^(j)) and the coefficients of         the generator polynomial G(x) are calculated, specifically:         G(x)=x⁵+0x3e*x⁴+0x318*x³+0x18c0*x²+0x7c00*x+0x8000;     -   it is assumed that each code word T_(n) of the redundant codes         is 0, then the code word polynomial

${Q(x)} = {\sum\limits_{l = t}^{t + k - 1}{K_{l} \cdot x^{l}}}$

is obtained, specifically:

Q(x)=0x1234*x ⁹+0x5678*x ⁸+0x3245*x ⁷+0xabcd*x ⁶+0xef10*x ⁵+0*x ⁴+0*x ³+0*x ²+0* x ¹+0*x ⁰;

-   -   the code word polynomial Q(x) is divided by the generator         polynomial G(x) to obtain a remainder polynomial

${R(x)} = {\sum\limits_{i = 0}^{2s}{T_{i} \cdot {x_{i}.}}}$

In calculating the remainder polynomial R(x), multiplication of coefficients of x will be performed, and the multiplication operation is converted into addition operation, specifically:

-   -   0x1234*0x18c0 is taken as an example;     -   the coefficients of x in the code word polynomial Q(x) and the         generator polynomial G(x) are represented by a polynomial         representation, specifically:

0x1234=0*α¹⁵+0*α¹⁴+0*α¹³+1*α¹²+0*α¹¹+0*α¹⁰+1*α⁹+0*α⁸+0*α⁷+0*α⁶+1*α⁵+1*α⁴+0*α³+1*α²+0*α¹+0*α⁰=α¹²+α⁹+α⁵+α⁴+α²;

0x18c0=0*α¹⁵+0*α¹⁴+0*α¹³+1*α¹²+1*α¹¹+0*α¹⁰+0*α⁹+0*α⁸+1*α⁷+1*α⁶+0*α⁵+0*α⁴+0*α³+0*α²+0*α¹+0*α⁰=α¹²+α¹¹+α⁷+α⁶;

-   -   the coefficients represented by the polynomial representation         are multiplied and expanded to obtain addition of different         power exponents of α:

0x 1234 * 0 x 18c 0 = (α¹² + α⁹ + α⁵ + α⁴ + α²) * (α¹² + α¹¹ + α⁷ + α⁶) = α²⁴ + α²¹ + α¹⁷ + α¹⁶ + α¹⁴ + α²³ + α²⁰ + α¹⁶ + α¹⁵ + α¹³ + α¹⁹ + α¹⁶ + α¹² + α¹¹ + α⁹ + α¹⁸ + α¹⁵ + α¹¹ + α¹⁰ + α⁸ = α²⁴ + α²³ + α²¹ + α²⁰ + α¹⁹ + α¹⁸ + α¹⁷ + α¹⁶ + α¹⁴ + α¹³ + α¹² + α¹⁰ + α⁹ + α⁸ = 0x 2d 00 + 0x 1680 + 0x 5 a 0 + 0x 2 d 0 + 0 x 168 + 0 x b 4 + 0x 5 a + 0x 2 d + 0x 4000 + 0x 2000 + 0x 1000 + 0x 400 + 0x 200 + 0x 100 = 0x 4 a 5b;

-   -   the numerical values of the power exponents of α are found out         through the lookup table f(α^(j)), and the coefficients of the         remainder polynomial R(x), i.e., the code words of the redundant         codes T_(n), n=1, 2, . . . , 5, are calculated;     -   the remainder polynomial R(x) is obtained:

|R(x)=0x15d4*x ⁴+0x2606*x ³+0x3587*x²+0x417e*x ¹+0x121c*x ⁰;

-   -   code words of the five redundant codes are 0x15d4, 0x2606,         0x3587, 0x417e, 0x121c;     -   the sending terminal sends five information data and five         redundant codes 0x1234, 0x5678, 0x3245, 0xabcd, 0xef10, 0x15d4,         0x2606, 0x3587, 0x417e, 0x121c to the receiving terminal.

It is assumed that the third information data and the third redundant code received by the receiving terminal are in error, then the information data and the redundant codes received by the receiving terminal are 0x1234, 0x5678, 0xe305, 0xabcd, 0xef10, 0x15d4, 0x2606, 0xa513, 0x417e , 0x121c.

The code word polynomial Q(x) obtained by the receiving terminal according to the received information data and redundant codes is:

Q(x)=0x1234*x ⁹+0x5678*x ⁸+0xe305*x ⁷+0xabcd*x ⁶+0xef10* x ⁵+0x15d4*x ⁴+0x2606*x ³+0x513*x ²+0x417e*x ¹+0x121c*x ⁰.

The receiving terminal calculates five correctors S_(i), where S_(i)=Q(α^(i)), i=1, 2, . . . , 5, specifically,

S ₁ =Q(α¹)=0xed82;

S ₂ =Q(α²)=0xc556;

S ₃ =Q(α³)=0x879a;

S ₄ =Q(α⁴)=0x4eb7;

S ₅ =Q(α⁵)=0x7cb9;

if not all of the correctors S_(i) are equal to 0, then the location of the error information code and the correction value are calculated using the correctors S₁ to S_(2s); specifically, calculation is performed according to the correctors to obtain the equation SS₂·x²+SS₁·x+SS₀=0, and the root of the equation is the location of the error code.

Let s₁=(s₁ s₂), s₂=(s₂ s₃), s₃=(s₃ s₄), then

SS ₂ =|S ₁ ^(T) S ₂ ^(T) |=S ₂ *S ₂ +S ₁ *S ₃=0x219f;

SS ₁ =|S ₁ ^(T) S ₃ ^(T) |=S ₄ *S ₁ +S ₃ *S ₂=0x4b2c;

SS ₀ =|S ₂ ^(T) S ₁ ^(T) |=S ₄ *S ₂ +S ₃ *S ₃=0x3537;

then the equation is 0x219f·x²+0x4b2c·|x+0x3537=0, and the solution to this equation is as follows:

the roots of the equation are represented by the polynomial representation, that is, x and x² are represented by the polynomial representation as:

x=x ₁₅α¹⁵ +x ₁₄α¹⁴ +x ₁₃α¹³ +x ₁₂α¹² +x ₁₁α¹¹ +x ₁₀α¹⁰ +x ₉α⁹ +x ₈α⁸ +x ₇α⁷ +x ₆α⁶ +x ₅α⁵ +x| ₄α⁴ x ₃α³ +x ₂α² +x ₁α¹ x ₀α⁰;

x ² =x ₁₅α³⁰ +x ₁₄α²⁸ +x ₁₃α²⁶ +x ₁₂α²⁴ +x ₁₁α²² +x ₁₀α²⁰ +x ₉α¹⁸ +x ₈α¹⁶ +x ₇α¹⁴ +x ₆α¹² +x ₅α¹⁰ +x ₄α⁸ +x ₃α⁶ +x ₂α⁴ +x ₁α² +x ₀α⁰;

-   -   where x_(i) can only take 0 or 1, i=1, 2, . . . , 15;     -   the values of x and x² are brought into the left of the equation         to obtain

0x219f*x ²+0x4b2c*x+0x3537=0xe006x ₁₅+0xe5c6x ₁₄+0x1799x ₁₃+0x1292x ₁₂+0x 2f1bx ₁₂+0x1e19x ₁₀+0x2d6cx ₉+0xbe3dx ₈+0x3537x ₇+0x6d1fx ₆+0 xoeabx ₅+0x28f9x ₄+0x3f92x ₃+0x3527x ₂+0x1024x ₁+0x6ab3x ₀;

-   -   the exponents of α corresponding to the coefficients of x_(i)         are looked for in the lookup table f(α^(j)), and the left side         of the equation is converted into the expression of the         exponents of α and x_(i), specifically:

0x219f*x²+0x4b2c*x+0x3537

=0xe006x ₁₅+0xe5c6x ₁₄+0x1799x ₁₃+0x1292x ₁₂+0x2f1bx ₁₁

+0x1e19x₁₀+0x2d6cx₉+0xbe3dx₈+0x3537x₇+0x6d1fx₆

+0xoeabx₅+0x28f9x₄+0x3f92x₃+0x3527x₂+0x1024x₁+0x6ab3x₀

=(x ₀ +x ₂ +x ₄ +x ₅ +x ₆ +x ₇ +x ₈ +x ₁₀ +x ₁₁ +x ₁₃+1)*α⁰

+(x₀+x₂+x₃+x₅+x₆+x₇+x₁₁+x₁₂+x₁₄+x₁₅+1)*α¹

+(x₁+x₂+x₆+x₇+x₈+x⁹+x₁₄+x₁₅+1)*α²

+(x₄+x₅+x₆+x₈+x₉+x₁₀+x₁₁+x₁₃+0)*α³

+(x₀+x₂+x₃+x₄+x₆+x₇+x₈+x₁₀+x₁₁+x₁₂+x₁₃+1)*α⁴

+(x₀+x₁+x₂+x₄+x₅+x₇+x₈+x₉+1)*α⁵

+(x₄+x₉+x₁₄+0)*α⁶

+(x₀+x₃+x₄+x₅+x₁₂+x₁₃+x₁₄+0)*α⁷

+(x₂+x₃+x₇+x₉+x₁₁+x₁₃+x₁₄+1)*α⁸

+(x₀+x₃+x₅+x₈+x₁₀+x₁₁+x₁₂+x₁₃+0)*α⁹

+(x₂+x₃+x₅+x₇+x₈+x₉+x₁₀+x₁₁+x₁₃+x₁₄+1)*α¹⁰

+(x₀+x₃+x₄+x₅+x₈+x₉+x₁₀+x₁₁+0)*α¹¹

+(x₁+x₂+x₃+x₇+x₈+x₁₀+x₁₂+x₁₃+1)*α¹²

+(x₀+x₂+x₃+x₄+x₆+x₇+x₈+x₉+x₁₁+x₁₄+x₁₅+1)*α¹³

+(x₀+x₆+x₁₄+x₁₅+0)*α¹⁴

+(x₈+x₁₄+x₁₅+0)*α¹⁵;

-   -   let all the above coefficients of α^(i) be equal to 0, thus         obtaining 16 equations:

x ₀ +x ₂ +x ₄ +x ₅ +x ₆ +x ₇ +x ₈ +x ₁₀ +x ₁₁ +x ₁₃=1;

x ₀ +x ₂ +x ₃ +x ₅ +x ₆ +x ₇ +x ₁₁ +x ₁₂ +x ₁₄ +x ₁₅=1;

x ₁ +x ₂ +x ₆ +x ₇ +x ₈ +x ⁹ +x ₁₄ +x ₁₅=1;

x ₄ +x ₅ +x ₆ +x ₈ +x ₉ +x ₁₀ +x ₁₁ +x ₁₃=0;

x ₀ +x ₂ +x ₃ +x ₄ +x ₆ +x ₇ +x ₈ +x ₁₀ +x ₁₁ +x ₁₂ +x ₁₃=1;

x ₀ +x ₁ +x ₂ +x ₄ +x ₅ +x ₇ +x ₈ +x ₉=1;

x ₄ +x ₉ +x ₁₄=0;

x ₀ +x ₃ +x ₄ +x ₅ +x ₁₂ +x ₁₃ +x ₁₄=0;

x ₂ +x ₃ +x ₇ +x ₉ +x ₁₁ +x ₁₃ +x ₁₄=1;

x ₀ +x ₃ +x ₅ +x ₈ +x ₁₀ +x ₁₁ +x ₁₂ +x ₁₃=0;

x ₂ +x ₃ +x ₅ +x ₇ +x ₈ +x ₉ +x ₁₀ +x ₁₁ +x ₁₃ +x ₁₄=1;

x ₀ +x ₃ +x ₄ +x ₅ +x ₈ +x ₉ +x ₁₀ +x ₁₁=0;

x ₁ +x ₂ +x ₃ +x ₇ +x ₈ +x ₁₀ +x ₁₂ +x ₁₃1;

x ₀ +x ₂ +x ₃ +x ₄ +x ₆ +x ₇ +x ₈ +x ₉ +x ₁₁ +x ₁₄ +x ₁₅1;

x ₀ +x ₆ +x ₁₄ +x ₁₅=0;

x ₈ +x ₁₄ +x ₁₅=0;

-   -   the above 16 equations are converted into a non-homogeneous         linear equation set for x_(i), and a matrix consisting of the         coefficients of x_(i)′ and numerical values of constant terms is         obtained:

$\begin{bmatrix} 1 & 0 & 1 & 0 & 1 & 1 & 1 & 1 & 1 & 0 & 1 & 1 & 0 & 1 & 0 & 0 & \; & 1 \\ 1 & 0 & 1 & 1 & 0 & 1 & 1 & 1 & 0 & 0 & 0 & 1 & 1 & 0 & 1 & 1 & \; & 1 \\ 0 & 1 & 1 & 0 & 0 & 0 & 1 & 1 & 1 & 1 & 0 & 0 & 0 & 0 & 1 & 1 & \; & 1 \\ 0 & 0 & 0 & 0 & 1 & 1 & 1 & 0 & 1 & 1 & 1 & 1 & 0 & 1 & 0 & 0 & \; & 0 \\ 1 & 0 & 1 & 1 & 1 & 0 & 1 & 1 & 1 & 0 & 1 & 1 & 1 & 1 & 0 & 0 & \; & 1 \\ 1 & 1 & 1 & 0 & 1 & 1 & 0 & 1 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & \; & 1 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & \; & 0 \\ 1 & 0 & 0 & 1 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 1 & 0 & \; & 0 \\ 0 & 0 & 1 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 1 & 0 & 1 & 1 & 0 & \; & 1 \\ 1 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 1 & 0 & 1 & 1 & 1 & 1 & 0 & 0 & \; & 0 \\ 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 & 1 & 1 & 1 & 1 & 0 & 1 & 1 & 0 & \; & 1 \\ 1 & 0 & 0 & 1 & 1 & 1 & 0 & 0 & 1 & 1 & 1 & 1 & 0 & 0 & 0 & 0 & \; & 0 \\ 0 & 1 & 1 & 1 & 0 & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 & 1 & 0 & 0 & \; & 1 \\ 1 & 0 & 1 & 1 & 1 & 0 & 1 & 1 & 1 & 1 & 0 & 1 & 0 & 0 & 1 & 1 & \; & 1 \\ 1 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & \; & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & \; & 0 \end{bmatrix};$

-   -   the above non-homogeneous linear equation set is solved to         obtain x₁=0x0004, x₂=0x0080;     -   in the lookup table f(α^(j)), the locations corresponding to x₁         and x₂ are the second power of α and the seventh power of α         respectively; thus, the locations of the error information codes         in the code word polynomial Q(x) are the coefficients         corresponding to the second power and the seventh power of x,         namely, 0xa513 and 0xe305.

If no values that are the same as the values of x₁ and x₂ are found in the lookup table f(α^(j)), the following method is used to find out the location of the error code, specifically:

-   -   in step S1, take p=2*m−1=31, v=α^(2m−1)=0x823e;     -   in step S2, let p=p+1;     -   in step S3, if the highest data bit of v is 1, v is firstly         shifted leftward by 1 bit, and     -   then v=v+0x1d, where 0x1d is the numerical value obtained by         bringing x=α into x⁵+x³+x²+1 in the primitive polynomial         P(x)=x¹⁶+x⁵+x³+x²+1;     -   if the highest data bit of v is 0, v is shifted leftward by 1         bit;     -   in step S4, the v obtained in step S3 is compared with x₁ or x₂         to see if they are equal:     -   if the v is equal to x₁ or x₂, the coefficient corresponding to         the p^(th) power of x in the code word polynomial Q (x) is the         location of the error information code; and     -   If the v is not equal to x₁ or x₂, then turn to step S2 to         continue the process.

The error value is calculated according to the following two equations:

S ₁ =e ₁ ·x ₁ +e ₂ ·x ₂=0xed82;

S ₂ =e ₁ ·x ₁ ² +e ₂ ·x ₂ ²=0xc556;

-   -   values of x₁ and x₂ are brought into the above two equations to         yield e₁=0x9094 and e₂=0xd140, specifically:     -   S₁*x₁−S₂ is calculated to yield (x₁·x₂−x₂ ²)·e₂=0xed82=0xc556;     -   e₂ is represented in polynomial representation as:

e ₂ =x1₅α¹⁵ +x ₁₄α¹⁴ +x ₁₃α¹³ +x ₁₂α¹² +x ₁₁α¹¹ +x ₁₀α¹⁰ +x ₉α⁹ +x ₈α⁸ +x ₇α⁷ +x ₆α⁶ +x ₅α⁵ +x ₄α⁴ +x ₃α³ +x ₂α² +x ₁α¹ +x ₀α⁰;

-   -   where x_(i) can only take 0 or 1, i=1, 2, . . . , 15;     -   the value of e₂ is brought into (x₁·x₂−x₂ ²)·e₂=0xed82−0xc556 to         obtain the non-homogeneous linear equation set and yield         e₂=0xd140;     -   and in a similar principle, yield e₁=0x9094;     -   the correction value is added to the code word at the location         of the error information code received by the receiving terminal         to obtain error-corrected code word, specifically:     -   in the error-corrected code word polynomial Q(x), the         coefficient of the second power of x is: 0xa513+0x9094=0x3587,         and the coefficient of the seventh power of x is:         0xe305+0xd140=0x3245;     -   the value of the error-corrected code word is assigned to the         code word at the location of the error information code so as to         obtain the error-corrected code word polynomial Q(x) as follows:

Q(x)=0x1234*x ⁹+0x5678*x ⁸+0x3245*x ⁷+0xabcd*x ⁶+0xef10*x ⁵+0x15d4*x ⁴+0x2606*x ³+0x3587*x ²+0x417e*x ¹+0x121c*x ⁰;

-   -   S₅=Q(α⁵) is recalculated, and if S₅=0 is yielded, the error         correction is successful.

To sum up, in the RS error correction decoding method according to the present invention, a lookup table f(α^(j)) for different power exponents of α is established, where j is selected from all the integers ranging from 0 to 2m−1, and with a total number of 2m, for the calculation of the coefficients of the generator polynomial G(x) and the coefficients of the remainder polynomial R(x) obtained by dividing the code word polynomial Q(x) by the generator polynomial G(x), thus greatly saving system memory; one additional redundant code is taken in encoding, for the purpose of checking the data obtained after the error correction decoding, thereby improving correctness and stability of the system. 

What is claimed is:
 1. A RS error correction decoding method, characterized in that, when encoding at a sending terminal, code words of information data are represented by K_(l), code words of redundant codes are represented by T_(n), the order of primitive polynomial P(x) is m, a generator polynomial in GF(2^(m)) is G(x), and an error correction code is represented by (c, k, t), wherein c is the total length of the information data and the redundant code, k is the length of the information data, and t is the length of the redundant code, then the code word polynomial Q(x) can be represented as ${{Q(x)} = {{\sum\limits_{l = t}^{t + k - 1}{K_{l} \cdot x^{l}}} + {\sum\limits_{n = 0}^{t - 1}{T_{n} \cdot x^{n}}}}};$ root of the m-order primitive polynomial P(x) is primitive field element in GF (2^(m)), and the primitive field element is represented by α, thus the generator polynomial G(x) can be represented as ${{G(x)} = {\prod\limits_{i = 1}^{t}\; \left( {x - \alpha^{i}} \right)}};$ a lookup table f(α^(j)) is established for different power exponents of α, wherein the value of j is selected from all the integers ranging from 0 to 2m−1, with a total number of 2m; the generator polynomial G(x) is expanded to obtain a polynomial with respect to x, wherein the coefficients of the generator polynomial G(x) are the addition or subtraction of the power exponents of α; numerical values of the different power exponents of α are found out through the lookup table f(α^(j)) and the coefficients of the generator polynomial G(x) are calculated; it is assumed that the code words T_(n) of the redundant codes are all 0, then a code word polynomial ${Q(x)} = {\sum\limits_{l = t}^{t + k - 1}{K_{l} \cdot x^{l}}}$ is obtained; the code word polynomial Q(x) is divided by the generator polynomial G(x) to obtain a remainder polynomial ${{R(x)} = {\sum\limits_{i = 0}^{2s}{T_{i} \cdot x_{i}}}};$ the coefficients Ti of R(x) are the addition or subtraction of the power exponents of α; numerical values of the power exponents of α are found out through the lookup table f(α^(j)), and the coefficients of the remainder polynomial R(x) are calculated, namely, the code words Tn of the redundant codes.
 2. The RS error correction decoding method according to claim 1, wherein the error correction decoding process includes: assuming that s is the maximum number of error correction bits of the receiving terminal, let t=2s+1; dividing the code word polynomial Q(x) by the generator polynomial G(x) to obtain the remainder polynomial R(x), ${{R(x)} = {\sum\limits_{i = 0}^{2s}{T_{i} \cdot x_{i}}}};$ calculating the coefficients of the remainder polynomial R(x), thus obtaining the code words T_(n) of 2s+1 redundant codes, n=1, 2, . . . , 2s+1; sending, by the sending terminal, information data and 2s+1 redundant codes to the receiving terminal; receiving, by the receiving terminal, the information data and 2s+1 redundant codes; obtaining, by the receiving terminal, the code word polynomial Q(x) according to the received information data and 2s+1 redundant codes, and the code word polynomial Q(x) being represented as: ${{Q(x)} = {{\sum\limits_{l = {{2s} + 1}}^{{2s} + k}{K_{l} \cdot x^{l}}} + {\sum\limits_{n = 0}^{2s}{T_{n} \cdot x^{n}}}}};$ calculating, by the receiving terminal, 2s+1 correctors S_(i), wherein S_(i)=Q(α^(i)), i=1, 2, . . . , 2s+1; calculating a location of an error information code and a correction value using correctors S₁to S_(2s), if not all of the correctors S, are equal to 0; adding the correction value to the code word at the location of the error information code received by the receiving terminal to obtain an error-corrected code word; assigning the value of the error-corrected code word to the code word at the location of the error information code; recalculating S_(2s+1)=Q(α^(2s+1)), wherein if S_(2s+1)=0, the error correction is successful.
 3. The RS error correction decoding method according to claim 1, wherein in the process of obtaining the remainder polynomial R(x) by dividing the code word polynomial Q(x) by the generator polynomial G(x), multiplication of the coefficients of x is performed, and the multiplication operation is converted into addition operation specifically as follows: representing the coefficients of x by a polynomial representation; multiplying and expanding the coefficients represented by the polynomial representation to obtain an addition of different power exponents of α; finding out the numerical values of the different power exponents of α through the lookup table f(α^(j)) to solve the addition.
 4. The RS error correction decoding method according to claim 1, wherein the process of calculating the location of the error information code using the correctors S₁to S_(2s) is specifically performed as follows: calculating according to the correctors to obtain an equation taking the location of the error information code as a root; representing the root of the equation by a polynomial representation, with standard bases being different power exponents of α and coefficients being values of X_(i), wherein i=0, 1, . . . , m; representing the coefficients of the equation by the polynomial representation, with standard bases being different power exponents of α; bringing the root and coefficients represented by the polynomial representation into the polynomial of the equation; letting the coefficient of each term of the polynomial be zero, thus obtaining a non-homogeneous linear equation set for x_(i); solving the non-homogeneous linear equation set to obtain the value of x_(i); substituting the value of x_(i) into the root represented by the polynomial representation to obtain by calculation the root of the equation so as to obtain the location of the error information code; looking for the location in the code word polynomial Q(x) corresponding to the location of the error information code.
 5. The RS error correction decoding method according to claim 4, wherein looking for the location in the code word polynomial Q(x) corresponding to the location of the error information code specifically includes: finding out the numerical value in the lookup table f(α^(j)) that is the same as the value of the error information code, the coefficient at the location where the exponent value of x in the polynomial Q(x) is equal to the exponent value of α corresponding to the numerical value is the location in the code word polynomial Q(x) corresponding to the error information code; if the numerical value that is the same as the value of the error information code is not found in the lookup table f(α^(j)), the following method is used to find out the location of the error information code, specifically: S1, taking p=2*m−1=31, v=α^(2m−1); S2, letting p=p+1; S3, if the highest data bit of v is 1, shifting v leftward by 1 bit firstly, and then v=v+v₀, wherein v₀ is the numerical value obtained by bringing x=α into the primitive polynomial P(x) except for the term of the highest power of x; if the highest data bit of v is 0, shifting v leftward by 1 bit; S4, comparing the v obtained in step S3 with the error information code to see whether they are equal: If the v is equal to the error information code, the coefficient corresponding to the p^(th) power of x in the code word polynomial Q (x) is the location of the error information code. If the v is not equal to the error information code, then turn to step S2 to continue the process.
 6. The RS error correction decoding method according to claim 4, wherein calculating the correction value using the correctors S₁ to S_(2s) is specifically as follows: obtaining a equation set consisting of the location of the error information code and the correction value, wherein the error information code is the root of the equation set, and the correction value is an unknown number of the equation set; representing the correction value of the equation set by the polynomial representation, with standard bases being different power exponents of α, and coefficients being values of x_(i), i=0, 1, . . . , m; representing the location of the error information code of the equation set by the polynomial representation, with standard bases being different power exponents of α; bringing the correction value and coefficients represented by the polynomial representations into the polynomial of the equation set; letting the coefficient of each term of the polynomial be zero, thus obtaining a non-homogeneous linear equation set for x_(i); solving the non-homogeneous linear equation set to obtain the value of x_(i); bringing the value of x_(i) into the correction value represented by the polynomial representation to obtain by calculation the root of the equation set so as to obtain the correction value. 